home *** CD-ROM | disk | FTP | other *** search
/ MPEG Toolkit / MPEG Toolkit.iso / win / mpg2w11b / mpeg2ply / display.c next >
Encoding:
C/C++ Source or Header  |  1997-01-01  |  23.8 KB  |  1,003 lines
  1. /* Copyright (C) 1994, MPEG Software Simulation Group. All Rights Reserved. */
  2.  
  3. /*
  4.  * Disclaimer of Warranty
  5.  *
  6.  * These software programs are available to the user without any license fee or
  7.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  8.  * any and all warranties, whether express, implied, or statuary, including any
  9.  * implied warranties or merchantability or of fitness for a particular
  10.  * purpose.  In no event shall the copyright-holder be liable for any
  11.  * incidental, punitive, or consequential damages of any kind whatsoever
  12.  * arising from the use of these programs.
  13.  *
  14.  * This disclaimer of warranty extends to the user of these programs and user's
  15.  * customers, employees, agents, transferees, successors, and assigns.
  16.  *
  17.  * The MPEG Software Simulation Group does not represent or warrant that the
  18.  * programs furnished hereunder are free of infringement of any third-party
  19.  * patents.
  20.  *
  21.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  22.  * are subject to royalty fees to patent holders.  Many of these patents are
  23.  * general enough such that they are unavoidable regardless of implementation
  24.  * design.
  25.  *
  26.  */
  27.  
  28.  
  29.  /* these routines are closely modeled after those from
  30.   * mpeg_play 2.0 by the Berkeley Plateau Research Group
  31.   */
  32.  
  33. #include <malloc.h>
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36.  
  37. #include "config.h"
  38. #include "global.h"
  39.  
  40. /* private prototypes */
  41. static void ditherframe _ANSI_ARGS_((unsigned char *src[]));
  42. static void dithertop _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  43. static void ditherbot _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  44. static void dithertop420 _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  45. static void ditherbot420 _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  46. static void ditherframeRGB _ANSI_ARGS_((unsigned char *src[]));
  47. static void dithertopRGB _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  48. static void ditherbotRGB _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  49. static void init_ditherRGB _ANSI_ARGS_((void));
  50.  
  51. /* local data */
  52. static unsigned char *dithered_image, *dithered_image2;
  53.  
  54. static unsigned char ytab[256+16];
  55. static unsigned char utab[128+16];
  56. static unsigned char vtab[128+16];
  57. static unsigned char pixel[256];
  58.  
  59. typedef void (*DITHER_FRAME_FUNC)(unsigned char **);
  60. typedef void (*DITHER_FIELD_FUNC)(unsigned char **,unsigned char *);
  61. static DITHER_FRAME_FUNC dither_frame;
  62. static DITHER_FIELD_FUNC dither_even, dither_odd;
  63.  
  64. /* color space conversion coefficients
  65.  *
  66.  * entries are {crv,cbu,cgu,cgv}
  67.  *
  68.  * crv=(255/224)*65536*(1-cr)/0.5
  69.  * cbu=(255/224)*65536*(1-cb)/0.5
  70.  * cgu=(255/224)*65536*(cb/cg)*(1-cb)/0.5
  71.  * cgv=(255/224)*65536*(cr/cg)*(1-cr)/0.5
  72.  *
  73.  * where Y=cr*R+cg*G+cb*B (cr+cg+cb=1)
  74.  */
  75. /*
  76. int convmat[8][4] = {
  77.   {117504, 138453, 13954, 34903}, /* no sequence_display_extension */
  78. /*  {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */
  79. /*  {104597, 132201, 25675, 53279}, /* unspecified */
  80. /*  {104597, 132201, 25675, 53279}, /* reserved */
  81. /*  {104448, 132798, 24759, 53109}, /* FCC */
  82. /*  {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */
  83. /*  {104597, 132201, 25675, 53279}, /* SMPTE 170M */
  84. /*  {117579, 136230, 16907, 35559}  /* SMPTE 240M (1987) */
  85. /* };
  86.  
  87. /* 4x4 ordered dither
  88.  *
  89.  * threshold pattern:
  90.  *   0  8  2 10
  91.  *  12  4 14  6
  92.  *   3 11  1  9
  93.  *  15  7 13  5
  94.  */
  95.  
  96. void dither(src)
  97. unsigned char *src[];
  98. {
  99.   if (prog_seq)
  100.      dither_frame(src);
  101.   else
  102.   {
  103.     if ((pict_struct==FRAME_PICTURE && topfirst) || pict_struct==BOTTOM_FIELD)
  104.     {
  105.       /* top field first */
  106.       dither_even(src,dithered_image);
  107.       dither_odd (src,dithered_image2);
  108.     }
  109.     else
  110.     {
  111.       /* bottom field first */
  112.       dither_odd (src,dithered_image);
  113.       dither_even(src,dithered_image2);
  114.     }
  115.   }
  116.   display_image(dithered_image);
  117. }
  118.  
  119. static void ditherframe(src)
  120. unsigned char *src[];
  121. {
  122.   int i,j;
  123.   int y,u,v;
  124.   unsigned char *py,*pu,*pv,*dst;
  125.  
  126.   py = src[0];
  127.   pu = src[1];
  128.   pv = src[2];
  129.  
  130. #ifdef _WIN32
  131.   dst = dithered_image+(coded_picture_height-1)*coded_picture_width;
  132. #else
  133.   dst = dithered_image;
  134. #endif
  135.  
  136.   for (j=0; j<coded_picture_height; j+=4)
  137.   {
  138.     /* line j + 0 */
  139.     for (i=0; i<coded_picture_width; i+=4)
  140.     {
  141.       y = *py++;
  142.       u = *pu++ >> 1;
  143.       v = *pv++ >> 1;
  144.       *dst++ = pixel[ytab[y]|utab[u]|vtab[v]];
  145.       y = *py++;
  146.       if (chroma_format==CHROMA444)
  147.       {
  148.         u = *pu++ >> 1;
  149.         v = *pv++ >> 1;
  150.       }
  151.       *dst++ = pixel[ytab[y+8]|utab[u+8]|vtab[v+8]];
  152.       y = *py++;
  153.       u = *pu++ >> 1;
  154.       v = *pv++ >> 1;
  155.       *dst++ = pixel[ytab[y+2]|utab[u+2]|vtab[v+2]];
  156.       y = *py++;
  157.       if (chroma_format==CHROMA444)
  158.       {
  159.         u = *pu++ >> 1;
  160.         v = *pv++ >> 1;
  161.       }
  162.       *dst++ = pixel[ytab[y+10]|utab[u+10]|vtab[v+10]];
  163.     }
  164.  
  165.     if (chroma_format==CHROMA420)
  166.     {
  167.       pu -= chrom_width;
  168.       pv -= chrom_width;
  169.     }
  170.  
  171. #ifdef _WIN32
  172.     dst -= 2*coded_picture_width;
  173. #endif
  174.  
  175.     /* line j + 1 */
  176.     for (i=0; i<coded_picture_width; i+=4)
  177.     {
  178.       y = *py++;
  179.       u = *pu++ >> 1;
  180.       v = *pv++ >> 1;
  181.       *dst++ = pixel[ytab[y+12]|utab[u+12]|vtab[v+12]];
  182.       y = *py++;
  183.       if (chroma_format==CHROMA444)
  184.       {
  185.         u = *pu++ >> 1;
  186.         v = *pv++ >> 1;
  187.       }
  188.       *dst++ = pixel[ytab[y+4]|utab[u+4]|vtab[v+4]];
  189.       y = *py++;
  190.       u = *pu++ >> 1;
  191.       v = *pv++ >> 1;
  192.       *dst++ = pixel[ytab[y+14]|utab[u+14]|vtab[v+14]];
  193.       y = *py++;
  194.       if (chroma_format==CHROMA444)
  195.       {
  196.         u = *pu++ >> 1;
  197.         v = *pv++ >> 1;
  198.       }
  199.       *dst++ = pixel[ytab[y+6]|utab[u+6]|vtab[v+6]];
  200.     }
  201.  
  202. #ifdef _WIN32
  203.     dst -= 2*coded_picture_width;
  204. #endif
  205.  
  206.     /* line j + 2 */
  207.     for (i=0; i<coded_picture_width; i+=4)
  208.     {
  209.       y = *py++;
  210.       u = *pu++ >> 1;
  211.       v = *pv++ >> 1;
  212.       *dst++ = pixel[ytab[y+3]|utab[u+3]|vtab[v+3]];
  213.       y = *py++;
  214.       if (chroma_format==CHROMA444)
  215.       {
  216.         u = *pu++ >> 1;
  217.         v = *pv++ >> 1;
  218.       }
  219.       *dst++ = pixel[ytab[y+11]|utab[u+11]|vtab[v+11]];
  220.       y = *py++;
  221.       u = *pu++ >> 1;
  222.       v = *pv++ >> 1;
  223.       *dst++ = pixel[ytab[y+1]|utab[u+1]|vtab[v+1]];
  224.       y = *py++;
  225.       if (chroma_format==CHROMA444)
  226.       {
  227.         u = *pu++ >> 1;
  228.         v = *pv++ >> 1;
  229.       }
  230.       *dst++ = pixel[ytab[y+9]|utab[u+9]|vtab[v+9]];
  231.     }
  232.  
  233.     if (chroma_format==CHROMA420)
  234.     {
  235.       pu -= chrom_width;
  236.       pv -= chrom_width;
  237.     }
  238.  
  239. #ifdef _WIN32
  240.     dst -= 2*coded_picture_width;
  241. #endif
  242.  
  243.     /* line j + 3 */
  244.     for (i=0; i<coded_picture_width; i+=4)
  245.     {
  246.       y = *py++;
  247.       u = *pu++ >> 1;
  248.       v = *pv++ >> 1;
  249.       *dst++ = pixel[ytab[y+15]|utab[u+15]|vtab[v+15]];
  250.       y = *py++;
  251.       if (chroma_format==CHROMA444)
  252.       {
  253.         u = *pu++ >> 1;
  254.         v = *pv++ >> 1;
  255.       }
  256.       *dst++ = pixel[ytab[y+7]|utab[u+7]|vtab[v+7]];
  257.       y = *py++;
  258.       u = *pu++ >> 1;
  259.       v = *pv++ >> 1;
  260.       *dst++ = pixel[ytab[y+13]|utab[u+13]|vtab[v+13]];
  261.       y = *py++;
  262.       if (chroma_format==CHROMA444)
  263.       {
  264.         u = *pu++ >> 1;
  265.         v = *pv++ >> 1;
  266.       }
  267.       *dst++ = pixel[ytab[y+5]|utab[u+5]|vtab[v+5]];
  268.     }
  269.  
  270. #ifdef _WIN32
  271.     dst -= 2*coded_picture_width;
  272. #endif
  273.   }
  274.  
  275. }
  276.  
  277. static void dithertop(src,dst)
  278. unsigned char *src[];
  279. unsigned char *dst;
  280. {
  281.   int i,j;
  282.   int y,y2,u,v;
  283.   unsigned char *py,*py2,*pu,*pv,*dst2;
  284.  
  285.   py = src[0];
  286.   py2 = src[0] + (coded_picture_width<<1);
  287.   pu = src[1];
  288.   pv = src[2];
  289.  
  290. #ifdef _WIN32
  291.   dst += (coded_picture_height-1)*coded_picture_width;
  292.   dst2 = dst - coded_picture_width;
  293. #else
  294.   dst2 = dst + coded_picture_width;
  295. #endif
  296.  
  297.   for (j=0; j<coded_picture_height; j+=4)
  298.   {
  299.     /* line j + 0, j + 1 */
  300.     for (i=0; i<coded_picture_width; i+=4)
  301.     {
  302.       y = *py++;
  303.       y2 = *py2++;
  304.       u = *pu++ >> 1;
  305.       v = *pv++ >> 1;
  306.       *dst++  = pixel[ytab[y]|utab[u]|vtab[v]];
  307.       *dst2++ = pixel[ytab[((y+y2)>>1)+12]|utab[u+12]|vtab[v+12]];
  308.  
  309.       y = *py++;
  310.       y2 = *py2++;
  311.       if (chroma_format==CHROMA444)
  312.       {
  313.         u = *pu++ >> 1;
  314.         v = *pv++ >> 1;
  315.       }
  316.       *dst++  = pixel[ytab[y+8]|utab[u+8]|vtab[v+8]];
  317.       *dst2++ = pixel[ytab[((y+y2)>>1)+4]|utab[u+4]|vtab[v+4]];
  318.  
  319.       y = *py++;
  320.       y2 = *py2++;
  321.       u = *pu++ >> 1;
  322.       v = *pv++ >> 1;
  323.       *dst++  = pixel[ytab[y+2]|utab[u+2]|vtab[v+2]];
  324.       *dst2++ = pixel[ytab[((y+y2)>>1)+14]|utab[u+14]|vtab[v+14]];
  325.  
  326.       y = *py++;
  327.       y2 = *py2++;
  328.       if (chroma_format==CHROMA444)
  329.       {
  330.         u = *pu++ >> 1;
  331.         v = *pv++ >> 1;
  332.       }
  333.       *dst++  = pixel[ytab[y+10]|utab[u+10]|vtab[v+10]];
  334.       *dst2++ = pixel[ytab[((y+y2)>>1)+6]|utab[u+6]|vtab[v+6]];
  335.     }
  336.  
  337.     py += coded_picture_width;
  338.  
  339.     if (j!=(coded_picture_height-4))
  340.       py2 += coded_picture_width;
  341.     else
  342.       py2 -= coded_picture_width;
  343.  
  344. #ifdef _WIN32
  345.     dst  = dst2 - 2*coded_picture_width;
  346.     dst2 = dst  - coded_picture_width;
  347. #else
  348.     dst += coded_picture_width;
  349.     dst2+= coded_picture_width;
  350. #endif
  351.  
  352.     if (chroma_format==CHROMA420)
  353.     {
  354.       pu -= chrom_width;
  355.       pv -= chrom_width;
  356.     }
  357.     else
  358.     {
  359.       pu += chrom_width;
  360.       pv += chrom_width;
  361.     }
  362.  
  363.     /* line j + 2. j + 3 */
  364.     for (i=0; i<coded_picture_width; i+=4)
  365.     {
  366.       y = *py++;
  367.       y2 = *py2++;
  368.       u = *pu++ >> 1;
  369.       v = *pv++ >> 1;
  370.       *dst++  = pixel[ytab[y+3]|utab[u+3]|vtab[v+3]];
  371.       *dst2++ = pixel[ytab[((y+y2)>>1)+15]|utab[u+15]|vtab[v+15]];
  372.  
  373.       y = *py++;
  374.       y2 = *py2++;
  375.       if (chroma_format==CHROMA444)
  376.       {
  377.         u = *pu++ >> 1;
  378.         v = *pv++ >> 1;
  379.       }
  380.       *dst++  = pixel[ytab[y+11]|utab[u+11]|vtab[v+11]];
  381.       *dst2++ = pixel[ytab[((y+y2)>>1)+7]|utab[u+7]|vtab[v+7]];
  382.  
  383.       y = *py++;
  384.       y2 = *py2++;
  385.       u = *pu++ >> 1;
  386.       v = *pv++ >> 1;
  387.       *dst++  = pixel[ytab[y+1]|utab[u+1]|vtab[v+1]];
  388.       *dst2++ = pixel[ytab[((y+y2)>>1)+13]|utab[u+13]|vtab[v+13]];
  389.  
  390.       y = *py++;
  391.       y2 = *py2++;
  392.       if (chroma_format==CHROMA444)
  393.       {
  394.         u = *pu++ >> 1;
  395.         v = *pv++ >> 1;
  396.       }
  397.       *dst++  = pixel[ytab[y+9]|utab[u+9]|vtab[v+9]];
  398.       *dst2++ = pixel[ytab[((y+y2)>>1)+5]|utab[u+5]|vtab[v+5]];
  399.     }
  400.  
  401.     py += coded_picture_width;
  402.     py2 += coded_picture_width;
  403. #ifdef _WIN32
  404.     dst  = dst2 - 2*coded_picture_width;
  405.     dst2 = dst  - coded_picture_width;
  406. #else
  407.     dst += coded_picture_width;
  408.     dst2+= coded_picture_width;
  409. #endif
  410.     pu += chrom_width;
  411.     pv += chrom_width;
  412.   }
  413. }
  414.  
  415. static void ditherbot(src,dst)
  416. unsigned char *src[];
  417. unsigned char *dst;
  418. {
  419.   int i,j;
  420.   int y,y2,u,v;
  421.   unsigned char *py,*py2,*pu,*pv,*dst2;
  422.  
  423.   py = src[0] + coded_picture_width;
  424.   py2 = py;
  425.   pu = src[1] + chrom_width;
  426.   pv = src[2] + chrom_width;
  427. #ifdef _WIN32
  428.   dst += (coded_picture_height-1)*coded_picture_width;
  429.   dst2 = dst - coded_picture_width;
  430. #else
  431.   dst2 = dst + coded_picture_width;
  432. #endif
  433.  
  434.   for (j=0; j<coded_picture_height; j+=4)
  435.   {
  436.     /* line j + 0, j + 1 */
  437.     for (i=0; i<coded_picture_width; i+=4)
  438.     {
  439.       y = *py++;
  440.       y2 = *py2++;
  441.       u = *pu++ >> 1;
  442.       v = *pv++ >> 1;
  443.       *dst++  = pixel[ytab[((y+y2)>>1)]|utab[u]|vtab[v]];
  444.       *dst2++ = pixel[ytab[y2+12]|utab[u+12]|vtab[v+12]];
  445.  
  446.       y = *py++;
  447.       y2 = *py2++;
  448.       if (chroma_format==CHROMA444)
  449.       {
  450.         u = *pu++ >> 1;
  451.         v = *pv++ >> 1;
  452.       }
  453.       *dst++  = pixel[ytab[y+8]|utab[u+8]|vtab[v+8]];
  454.       *dst2++ = pixel[ytab[y2+4]|utab[u+4]|vtab[v+4]];
  455.  
  456.       y = *py++;
  457.       y2 = *py2++;
  458.       u = *pu++ >> 1;
  459.       v = *pv++ >> 1;
  460.       *dst++  = pixel[ytab[((y+y2)>>1)+2]|utab[u+2]|vtab[v+2]];
  461.       *dst2++ = pixel[ytab[y2+14]|utab[u+14]|vtab[v+14]];
  462.  
  463.       y = *py++;
  464.       y2 = *py2++;
  465.       if (chroma_format==CHROMA444)
  466.       {
  467.         u = *pu++ >> 1;
  468.         v = *pv++ >> 1;
  469.       }
  470.       *dst++  = pixel[ytab[((y+y2)>>1)+10]|utab[u+10]|vtab[v+10]];
  471.       *dst2++ = pixel[ytab[y2+6]|utab[u+6]|vtab[v+6]];
  472.     }
  473.  
  474.     if (j==0)
  475.       py -= coded_picture_width;
  476.     else
  477.       py += coded_picture_width;
  478.  
  479.     py2 += coded_picture_width;
  480. #ifdef _WIN32
  481.     dst  = dst2 - 2*coded_picture_width;
  482.     dst2 = dst  - coded_picture_width;
  483. #else
  484.     dst += coded_picture_width;
  485.     dst2+= coded_picture_width;
  486. #endif
  487.  
  488.     if (chroma_format==CHROMA420)
  489.     {
  490.       pu -= chrom_width;
  491.       pv -= chrom_width;
  492.     }
  493.     else
  494.     {
  495.       pu += chrom_width;
  496.       pv += chrom_width;
  497.     }
  498.  
  499.     /* line j + 2. j + 3 */
  500.     for (i=0; i<coded_picture_width; i+=4)
  501.     {
  502.       y = *py++;
  503.       y2 = *py2++;
  504.       u = *pu++ >> 1;
  505.       v = *pv++ >> 1;
  506.       *dst++  = pixel[ytab[((y+y2)>>1)+3]|utab[u+3]|vtab[v+3]];
  507.       *dst2++ = pixel[ytab[y2+15]|utab[u+15]|vtab[v+15]];
  508.  
  509.       y = *py++;
  510.       y2 = *py2++;
  511.       if (chroma_format==CHROMA444)
  512.       {
  513.         u = *pu++ >> 1;
  514.         v = *pv++ >> 1;
  515.       }
  516.       *dst++  = pixel[ytab[((y+y2)>>1)+11]|utab[u+11]|vtab[v+11]];
  517.       *dst2++ = pixel[ytab[y2+7]|utab[u+7]|vtab[v+7]];
  518.  
  519.       y = *py++;
  520.       y2 = *py2++;
  521.       u = *pu++ >> 1;
  522.       v = *pv++ >> 1;
  523.       *dst++  = pixel[ytab[((y+y2)>>1)+1]|utab[u+1]|vtab[v+1]];
  524.       *dst2++ = pixel[ytab[y2+13]|utab[u+13]|vtab[v+13]];
  525.  
  526.       y = *py++;
  527.       y2 = *py2++;
  528.       if (chroma_format==CHROMA444)
  529.       {
  530.         u = *pu++ >> 1;
  531.         v = *pv++ >> 1;
  532.       }
  533.       *dst++  = pixel[ytab[((y+y2)>>1)+9]|utab[u+9]|vtab[v+9]];
  534.       *dst2++ = pixel[ytab[y2+5]|utab[u+5]|vtab[v+5]];
  535.     }
  536.  
  537.     py += coded_picture_width;
  538.     py2 += coded_picture_width;
  539. #ifdef _WIN32
  540.     dst  = dst2 - 2*coded_picture_width;
  541.     dst2 = dst  - coded_picture_width;
  542. #else
  543.     dst += coded_picture_width;
  544.     dst2+= coded_picture_width;
  545. #endif
  546.     pu += chrom_width;
  547.     pv += chrom_width;
  548.   }
  549. }
  550.  
  551. void init_dither(int bpp)
  552. {
  553.   int i, v;
  554.  
  555.   if ( bpp==8 )
  556.   {
  557.      dither_frame=ditherframe;
  558.      dither_even =dithertop;
  559.      dither_odd  =ditherbot;
  560.   }
  561.   else
  562.      error("unsuported dither type");
  563.  
  564.   bpp/=8;
  565.   if(!(dithered_image = (unsigned char *)malloc(bpp*coded_picture_width*
  566.                                                 coded_picture_height)))
  567.     error("malloc failed");
  568.  
  569.   if(!(dithered_image2 = (unsigned char *)malloc(bpp*coded_picture_width*
  570.                                                  coded_picture_height)))
  571.     error("malloc failed");
  572.  
  573.   for (i=-8; i<256+8; i++)
  574.   {
  575.     v = i>>4;
  576.     if (v<1)
  577.       v = 1;
  578.     else if (v>14)
  579.       v = 14;
  580.     ytab[i+8] = v<<4;
  581.   }
  582.  
  583.   for (i=0; i<128+16; i++)
  584.   {
  585.     v = (i-40)>>4;
  586.     if (v<0)
  587.       v = 0;
  588.     else if (v>3)
  589.       v = 3;
  590.     utab[i] = v<<2;
  591.     vtab[i] = v;
  592.   }
  593.  
  594.   for (i=0; i<256; i++)
  595.      pixel[i]=i;
  596. }
  597.  
  598. /*
  599.  portable display function
  600. */
  601. void display_second_field()
  602. {
  603.   display_image(dithered_image2);
  604. }
  605.  
  606. #if 0
  607. //
  608. // This code does not work
  609. //
  610.  
  611. static unsigned char uvtab[256*269+270];
  612.  
  613. static void ditherframe(src)
  614. unsigned char *src[];
  615. {
  616.   int i,j;
  617.   unsigned int uv;
  618.   unsigned char *py,*pu,*pv,*dst;
  619.  
  620.   py = src[0];
  621.   pu = src[1];
  622.   pv = src[2];
  623.  
  624. #ifdef _WIN32
  625.   dst = dithered_image+(coded_picture_height-1)*coded_picture_width;
  626. #else
  627.   dst = dithered_image;
  628. #endif
  629.  
  630.   for (j=0; j<coded_picture_height; j+=4)
  631.   {
  632.     /* line j + 0 */
  633.     for (i=0; i<coded_picture_width; i+=8)
  634.     {
  635.       uv = uvtab[(*pu++<<8)|*pv++];
  636.       *dst++ = ytab[((*py++)<<4)|(uv&15)];
  637.       *dst++ = ytab[((*py++ +8)<<4)|(uv>>4)];
  638.       uv = uvtab[((*pu++<<8)|*pv++)+1028];
  639.       *dst++ = ytab[((*py++ +2)<<4)|(uv&15)];
  640.       *dst++ = ytab[((*py++ +10)<<4)|(uv>>4)];
  641.       uv = uvtab[(*pu++<<8)|*pv++];
  642.       *dst++ = ytab[((*py++)<<4)|(uv&15)];
  643.       *dst++ = ytab[((*py++ +8)<<4)|(uv>>4)];
  644.       uv = uvtab[((*pu++<<8)|*pv++)+1028];
  645.       *dst++ = ytab[((*py++ +2)<<4)|(uv&15)];
  646.       *dst++ = ytab[((*py++ +10)<<4)|(uv>>4)];
  647.     }
  648.  
  649.     if (chroma_format==CHROMA420)
  650.     {
  651.       pu -= chrom_width;
  652.       pv -= chrom_width;
  653.     }
  654. #ifdef _WIN32
  655.     dst -= 2*coded_picture_width;
  656. #endif
  657.  
  658.     /* line j + 1 */
  659.     for (i=0; i<coded_picture_width; i+=8)
  660.     {
  661.       uv = uvtab[((*pu++<<8)|*pv++)+2056];
  662.       *dst++ = ytab[((*py++ +12)<<4)|(uv>>4)];
  663.       *dst++ = ytab[((*py++ +4)<<4)|(uv&15)];
  664.       uv = uvtab[((*pu++<<8)|*pv++)+3084];
  665.       *dst++ = ytab[((*py++ +14)<<4)|(uv>>4)];
  666.       *dst++ = ytab[((*py++ +6)<<4)|(uv&15)];
  667.       uv = uvtab[((*pu++<<8)|*pv++)+2056];
  668.       *dst++ = ytab[((*py++ +12)<<4)|(uv>>4)];
  669.       *dst++ = ytab[((*py++ +4)<<4)|(uv&15)];
  670.       uv = uvtab[((*pu++<<8)|*pv++)+3084];
  671.       *dst++ = ytab[((*py++ +14)<<4)|(uv>>4)];
  672.       *dst++ = ytab[((*py++ +6)<<4)|(uv&15)];
  673.     }
  674. #ifdef _WIN32
  675.     dst -= 2*coded_picture_width;
  676. #endif
  677.  
  678.     /* line j + 2 */
  679.     for (i=0; i<coded_picture_width; i+=8)
  680.     {
  681.       uv = uvtab[((*pu++<<8)|*pv++)+1542];
  682.       *dst++ = ytab[((*py++ +3)<<4)|(uv&15)];
  683.       *dst++ = ytab[((*py++ +11)<<4)|(uv>>4)];
  684.       uv = uvtab[((*pu++<<8)|*pv++)+514];
  685.       *dst++ = ytab[((*py++ +1)<<4)|(uv&15)];
  686.       *dst++ = ytab[((*py++ +9)<<4)|(uv>>4)];
  687.       uv = uvtab[((*pu++<<8)|*pv++)+1542];
  688.       *dst++ = ytab[((*py++ +3)<<4)|(uv&15)];
  689.       *dst++ = ytab[((*py++ +11)<<4)|(uv>>4)];
  690.       uv = uvtab[((*pu++<<8)|*pv++)+514];
  691.       *dst++ = ytab[((*py++ +1)<<4)|(uv&15)];
  692.       *dst++ = ytab[((*py++ +9)<<4)|(uv>>4)];
  693.     }
  694.  
  695.     if (chroma_format==CHROMA420)
  696.     {
  697.       pu -= chrom_width;
  698.       pv -= chrom_width;
  699.     }
  700. #ifdef _WIN32
  701.     dst -= 2*coded_picture_width;
  702. #endif
  703.  
  704.     /* line j + 3 */
  705.     for (i=0; i<coded_picture_width; i+=8)
  706.     {
  707.       uv = uvtab[((*pu++<<8)|*pv++)+3598];
  708.       *dst++ = ytab[((*py++ +15)<<4)|(uv>>4)];
  709.       *dst++ = ytab[((*py++ +7)<<4)|(uv&15)];
  710.       uv = uvtab[((*pu++<<8)|*pv++)+2570];
  711.       *dst++ = ytab[((*py++ +13)<<4)|(uv>>4)];
  712.       *dst++ = ytab[((*py++ +5)<<4)|(uv&15)];
  713.       uv = uvtab[((*pu++<<8)|*pv++)+3598];
  714.       *dst++ = ytab[((*py++ +15)<<4)|(uv>>4)];
  715.       *dst++ = ytab[((*py++ +7)<<4)|(uv&15)];
  716.       uv = uvtab[((*pu++<<8)|*pv++)+2570];
  717.       *dst++ = ytab[((*py++ +13)<<4)|(uv>>4)];
  718.       *dst++ = ytab[((*py++ +5)<<4)|(uv&15)];
  719.     }
  720. #ifdef _WIN32
  721.     dst -= 2*coded_picture_width;
  722. #endif
  723.   }
  724. }
  725.  
  726. static void dithertop(src,dst)
  727. unsigned char *src[];
  728. unsigned char *dst;
  729. {
  730.   int i,j;
  731.   unsigned int y,uv1,uv2;
  732.   unsigned char *py,*py2,*pu,*pv,*dst2;
  733.  
  734.   py = src[0];
  735.   py2 = src[0] + (coded_picture_width<<1);
  736.   pu = src[1];
  737.   pv = src[2];
  738. #ifdef _WIN32
  739.   dst += (coded_picture_height-1)*coded_picture_width;
  740.   dst2 = dst - coded_picture_width;
  741. #else
  742.   dst2 = dst + coded_picture_width;
  743. #endif
  744.  
  745.   for (j=0; j<coded_picture_height; j+=4)
  746.   {
  747.     /* line j + 0, j + 1 */
  748.     for (i=0; i<coded_picture_width; i+=4)
  749.     {
  750.       y = *py++;
  751.       uv2 = (*pu++<<8)|*pv++;
  752.       uv1 = uvtab[uv2];
  753.       uv2 = uvtab[uv2+2056];
  754.       *dst++  = ytab[((y)<<4)|(uv1&15)];
  755.       *dst2++ = ytab[((((y + *py2++)>>1)+12)<<4)|(uv2>>4)];
  756.  
  757.       y = *py++;
  758.       *dst++  = ytab[((y+8)<<4)|(uv1>>4)];
  759.       *dst2++ = ytab[((((y + *py2++)>>1)+4)<<4)|(uv2&15)];
  760.  
  761.       y = *py++;
  762.       uv2 = (*pu++<<8)|*pv++;
  763.       uv1 = uvtab[uv2+1028];
  764.       uv2 = uvtab[uv2+3072];
  765.       *dst++  = ytab[((y+2)<<4)|(uv1&15)];
  766.       *dst2++ = ytab[((((y + *py2++)>>1)+14)<<4)|(uv2>>4)];
  767.  
  768.       y = *py++;
  769.       *dst++  = ytab[((y+10)<<4)|(uv1>>4)];
  770.       *dst2++ = ytab[((((y + *py2++)>>1)+6)<<4)|(uv2&15)];
  771.     }
  772.  
  773.     py += coded_picture_width;
  774.  
  775.     if (j!=(coded_picture_height-4))
  776.       py2 += coded_picture_width;
  777.     else
  778.       py2 -= coded_picture_width;
  779.  
  780. #ifdef _WIN32
  781.     dst  = dst2 - 2*coded_picture_width;
  782.     dst2 = dst  - coded_picture_width;
  783. #else
  784.     dst += coded_picture_width;
  785.     dst2+= coded_picture_width;
  786. #endif
  787.  
  788.     if (chroma_format==CHROMA420)
  789.     {
  790.       pu -= chrom_width;
  791.       pv -= chrom_width;
  792.     }
  793.     else
  794.     {
  795.       pu += chrom_width;
  796.       pv += chrom_width;
  797.     }
  798.  
  799.     /* line j + 2, j + 3 */
  800.     for (i=0; i<coded_picture_width; i+=4)
  801.     {
  802.       y = *py++;
  803.       uv2 = (*pu++<<8)|*pv++;
  804.       uv1 = uvtab[uv2+1542];
  805.       uv2 = uvtab[uv2+3598];
  806.       *dst++  = ytab[((y+3)<<4)|(uv1&15)];
  807.       *dst2++ = ytab[((((y + *py2++)>>1)+15)<<4)|(uv2>>4)];
  808.  
  809.       y = *py++;
  810.       *dst++  = ytab[((y+11)<<4)|(uv1>>4)];
  811.       *dst2++ = ytab[((((y + *py2++)>>1)+7)<<4)|(uv2&15)];
  812.  
  813.       y = *py++;
  814.       uv2 = (*pu++<<8)|*pv++;
  815.       uv1 = uvtab[uv2+514];
  816.       uv2 = uvtab[uv2+2570];
  817.       *dst++  = ytab[((y+1)<<4)|(uv1&15)];
  818.       *dst2++ = ytab[((((y + *py2++)>>1)+13)<<4)|(uv2>>4)];
  819.  
  820.       y = *py++;
  821.       *dst++  = ytab[((y+9)<<4)|(uv1>>4)];
  822.       *dst2++ = ytab[((((y + *py2++)>>1)+5)<<4)|(uv2&15)];
  823.     }
  824.  
  825.     py += coded_picture_width;
  826.     py2 += coded_picture_width;
  827. #ifdef _WIN32
  828.     dst  = dst2 - 2*coded_picture_width;
  829.     dst2 = dst  - coded_picture_width;
  830. #else
  831.     dst += coded_picture_width;
  832.     dst2+= coded_picture_width;
  833. #endif
  834.     pu += chrom_width;
  835.     pv += chrom_width;
  836.   }
  837. }
  838.  
  839. static void ditherbot(src,dst)
  840. unsigned char *src[];
  841. unsigned char *dst;
  842. {
  843.   int i,j;
  844.   unsigned int y2,uv1,uv2;
  845.   unsigned char *py,*py2,*pu,*pv,*dst2;
  846.  
  847.   py = src[0] + coded_picture_width;
  848.   py2 = py;
  849.   pu = src[1] + chrom_width;
  850.   pv = src[2] + chrom_width;
  851. #ifdef _WIN32
  852.   dst += (coded_picture_height-1)*coded_picture_width;
  853.   dst2 = dst - coded_picture_width;
  854. #else
  855.   dst2 = dst + coded_picture_width;
  856. #endif
  857.  
  858.   for (j=0; j<coded_picture_height; j+=4)
  859.   {
  860.     /* line j + 0, j + 1 */
  861.     for (i=0; i<coded_picture_width; i+=4)
  862.     {
  863.       y2 = *py2++;
  864.       uv2 = (*pu++<<8)|*pv++;
  865.       uv1 = uvtab[uv2];
  866.       uv2 = uvtab[uv2+2056];
  867.       *dst++  = ytab[((((*py++ + y2)>>1))<<4)|(uv1&15)];
  868.       *dst2++ = ytab[((y2+12)<<4)|(uv2>>4)];
  869.  
  870.       y2 = *py2++;
  871.       *dst++  = ytab[((((*py++ + y2)>>1)+8)<<4)|(uv1>>4)];
  872.       *dst2++ = ytab[((y2+4)<<4)|(uv2&15)];
  873.  
  874.       y2 = *py2++;
  875.       uv2 = (*pu++<<8)|*pv++;
  876.       uv1 = uvtab[uv2+1028];
  877.       uv2 = uvtab[uv2+3072];
  878.       *dst++  = ytab[((((*py++ + y2)>>1)+2)<<4)|(uv1&15)];
  879.       *dst2++ = ytab[((y2+14)<<4)|(uv2>>4)];
  880.  
  881.       y2 = *py2++;
  882.       *dst++  = ytab[((((*py++ + y2)>>1)+10)<<4)|(uv1>>4)];
  883.       *dst2++ = ytab[((y2+6)<<4)|(uv2&15)];
  884.     }
  885.  
  886.     if (j==0)
  887.       py -= coded_picture_width;
  888.     else
  889.       py += coded_picture_width;
  890.  
  891.     py2 += coded_picture_width;
  892. #ifdef _WIN32
  893.     dst  = dst2 - 2*coded_picture_width;
  894.     dst2 = dst  - coded_picture_width;
  895. #else
  896.     dst += coded_picture_width;
  897.     dst2+= coded_picture_width;
  898. #endif
  899.  
  900.     if (chroma_format==CHROMA420)
  901.     {
  902.       pu -= chrom_width;
  903.       pv -= chrom_width;
  904.     }
  905.     else
  906.     {
  907.       pu += chrom_width;
  908.       pv += chrom_width;
  909.     }
  910.  
  911.     /* line j + 2, j + 3 */
  912.     for (i=0; i<coded_picture_width; i+=4)
  913.     {
  914.       y2 = *py2++;
  915.       uv2 = (*pu++<<8)|*pv++;
  916.       uv1 = uvtab[uv2+1542];
  917.       uv2 = uvtab[uv2+3598];
  918.       *dst++  = ytab[((((*py++ + y2)>>1)+3)<<4)|(uv1&15)];
  919.       *dst2++ = ytab[((y2+15)<<4)|(uv2>>4)];
  920.  
  921.       y2 = *py2++;
  922.       *dst++  = ytab[((((*py++ + y2)>>1)+11)<<4)|(uv1>>4)];
  923.       *dst2++ = ytab[((y2+7)<<4)|(uv2&15)];
  924.  
  925.       y2 = *py2++;
  926.       uv2 = (*pu++<<8)|*pv++;
  927.       uv1 = uvtab[uv2+514];
  928.       uv2 = uvtab[uv2+2570];
  929.       *dst++  = ytab[((((*py++ + y2)>>1)+1)<<4)|(uv1&15)];
  930.       *dst2++ = ytab[((y2+13)<<4)|(uv2>>4)];
  931.  
  932.       y2 = *py2++;
  933.       *dst++  = ytab[((((*py++ + y2)>>1)+9)<<4)|(uv1>>4)];
  934.       *dst2++ = ytab[((y2+5)<<4)|(uv2&15)];
  935.     }
  936.  
  937.     py += coded_picture_width;
  938.     py2 += coded_picture_width;
  939. #ifdef _WIN32
  940.     dst  = dst2 - 2*coded_picture_width;
  941.     dst2 = dst  - coded_picture_width;
  942. #else
  943.     dst += coded_picture_width;
  944.     dst2+= coded_picture_width;
  945. #endif
  946.     pu += chrom_width;
  947.     pv += chrom_width;
  948.   }
  949. }
  950. void init_dither(int bpp)
  951. {
  952.   int i, j, v;
  953.   unsigned char ctab[256+32];
  954.  
  955.   if ( bpp==8 )
  956.   {
  957.      dither_frame=ditherframe;
  958.      dither_even =dithertop;
  959.      dither_odd  =ditherbot;
  960.   }
  961.   else
  962.      error("unsuported dither type");
  963.  
  964.   bpp/=8;
  965.   if(!(dithered_image = (unsigned char *)malloc(bpp*coded_picture_width*
  966.                                                 coded_picture_height)))
  967.     error("malloc failed");
  968.  
  969.   if(!(dithered_image2 = (unsigned char *)malloc(bpp*coded_picture_width*
  970.                                                  coded_picture_height)))
  971.     error("malloc failed");
  972.  
  973.   for (i=0; i<256; i++)
  974.      pixel[i]=i;
  975.  
  976.   for (i=0; i<256+16; i++)
  977.   {
  978.     v = (i-8)>>4;
  979.     if (v<2)
  980.       v = 2;
  981.     else if (v>14)
  982.       v = 14;
  983.     for (j=0; j<16; j++)
  984.       ytab[16*i+j] = pixel[(v<<4)+j];
  985.   }
  986.  
  987.   for (i=0; i<256+32; i++)
  988.   {
  989.     v = (i+48-128)>>5;
  990.     if (v<0)
  991.       v = 0;
  992.     else if (v>3)
  993.       v = 3;
  994.     ctab[i] = v;
  995.   }
  996.  
  997.   for (i=0; i<255+15; i++)
  998.     for (j=0; j<255+15; j++)
  999.       uvtab[256*i+j]=(ctab[i+16]<<6)|(ctab[j+16]<<4)|(ctab[i]<<2)|ctab[j];
  1000.  
  1001. }
  1002. #endif
  1003.